package com.fsdcic.common.util;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.alibaba.fastjson.parser.Feature;
import com.alibaba.fastjson.serializer.NameFilter;
import com.alibaba.fastjson.serializer.SerializerFeature;

public class JsonUtil {
	/**
	 * 转换单个json对象为map
	 * @param json
	 * @return
	 */
	public static Map<String, Object> jsonObjectToMap(JSONObject json) {
		//构�?�成无序的map,性能较高
		//return JSON.parseObject(json.toJSONString(),new TypeReference<Map<String, String>>() {});
		
		//构�?�成有序的map,性能相对较慢
		return JSON.parseObject(json.toJSONString(),new TypeReference<LinkedHashMap<String, Object>>() {}, Feature.OrderedField);
	}

	/**
	 * 转换json字符串为List<Map>对象
	 * @param jsonList
	 * @return
	 */
	public static List<Map<String, Object>> stringToListMap(String jsonList) {
		try {
			List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
			JSONArray array = JsonUtil.stringToJson(jsonList);
			for (int i = 0; i < array.size(); i++) {
				result.add(jsonObjectToMap((JSONObject) array.get(i)));
			}
			return result;
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}

	}
	
	/**
	 * 转换json字符串为map对象
	 * @param jsonStr
	 * @return
	 */
	public static Map<String,Object> stringToMap(String jsonStr){
		Map<String,Object> obj = new HashMap<String, Object>();
		if(jsonStr != null && !"".equals(jsonStr.trim())){
			obj = JSON.parseObject(jsonStr, Map.class);
		}
		return obj;
	}
	
	/**
	 * 对特殊字符进行转�?
	 * 说明：这个方法是默认key不会违法，只是内容会违法的情�?
	 * @param jsonStr
	 * @return
	 */
	public static String stringFilter(String jsonStr){
		StringBuffer returnStr = new StringBuffer();
		if(jsonStr == null || "".equals(jsonStr.trim())){
			return jsonStr;
		}
		int length = jsonStr.length();
		String curValue = null;
		String nextValue = null;
		String curVal = null;
		String nextVal = null;
		//大循环~~~~~~~~~~~~~~~~
		for (int i = 0; i < length; i++) {
			curValue = null;
			curValue = jsonStr.substring(i,i + 1);
			//如果值是：号，并且下�?个�?�是"号时，就是内容的�?�?
			if(":".equals(curValue)){
				nextValue = null;
				nextValue = jsonStr.substring(i+1,i + 2);
				if("\"".equals(nextValue)){
					//补回:"进返回字符串
					returnStr.append(":\"");
					//小循环~~~~~~~~~~~~~~~~~
					for (int j = i + 2; j < length; j++) {
						//把当前序号同步回i
						i = j;
						curVal = null;
						curVal = jsonStr.substring(j,j+1);
						//如果值等�? "号时，要特殊处理，因为涉及到每个key的边�?
						//并且下一个�?�不�?,号或者}号时，对当前值进行处�?
						if ("\"".equals(curVal)) {
							nextVal = null;
							nextVal = jsonStr.substring(j+1,j+2);
							//"号要单独做判断，因为涉及到每个key的结束�??
	                        if (!",".equals(nextVal) && !"}".equals(nextVal)) {
	                        	returnStr.append("\\\"");
	                        } else if (",".equals(nextVal) || "}".equals(nextVal)) {  
	                        	//如果下一个�?�是,号或�? }号时，不作处理，并跳出小循环，进行下�?个key的内容处�?
	                        	returnStr.append(curVal);
	                        	break;
							}
						} else {
							//如果当前值不�?"时，只做常规特殊字符转义
							switch (curVal) {
							case "\\": // 如果不处理单引号，可以释放此段代码，若结合下面的方法处理单引号就必须注释掉该段代�?
								returnStr.append("\\\\");
								break;
							case "\'":
								returnStr.append("\\\'");
								break;
							case "/":
								returnStr.append("\\/");
								break;
							case "\b": // �?�?
								returnStr.append("\\b");
								break;
							case "\f": // 走纸换页
								returnStr.append("\\f");
								break;
							case "\n":// 换行
								returnStr.append("\\n");
								break;
							case "\r": // 回车
								returnStr.append("\\r");
								break;
							case "\t": // 横向跳格
								returnStr.append("\\t");
								break;
							default:
								returnStr.append(curVal);
							}
						}
					}
				}else{
					//如果是{或[之类符号时，只需要追加当前�??
					returnStr.append(curValue);
				}
			}else{
				//如果未到内容�?头时，只�?要追加当前�??
				returnStr.append(curValue);
			}
		}
		return returnStr.toString();
	}
	
	/**
	 * json中的key转大�?
	 * @param jsonstr
	 * @return
	 */
	public static String keyToUpper4Object(String jsonstr){
		if(jsonstr == null || "".equals(jsonstr.trim())){
			return jsonstr;
		}
		System.out.println("大写转换前：" + jsonstr);
		String str = JSON.toJSONString(JSON.parseObject(jsonstr),new NameFilter() {
			@Override
			public String process(Object obj, String name, Object value) {
				return name.toUpperCase();
			}
		});
		System.out.println("大写转换后：" + str);
		return str;
	}
	
	/**
	 * json中的key转大�?
	 * @param jsonstr
	 * @return
	 */
	public static String keyToUpper4Array(String jsonstr){
		if(jsonstr == null || "".equals(jsonstr.trim())){
			return jsonstr;
		}
		System.out.println("大写转换前：" + jsonstr);
		String str = JSON.toJSONString(JSON.parseArray(jsonstr),new NameFilter() {
			@Override
			public String process(Object obj, String name, Object value) {
				return name.toUpperCase();
			}
		});
		System.out.println("大写转换后：" + str);
		return str;
	}
	
	

	public void test(){
		//取消映射引用
		//JSON.toJSONString(obj,SerializerFeature.DisableCircularReferenceDetect)
		
		//字段按原来顺序进行序列化
		//JSON.parseObject(params,new TypeReference<LinkedHashMap<String, Object>>(){} , Feature.OrderedField);
	}
	
	// 转换字符串为json对象数组
	private static JSONArray stringToJson(String jsonList) {
		return JSON.parseArray(jsonList);
	}
	
	private static String mapToString(Map<String, String> json) {
		return JSON.toJSONString(json);
	}
}
